Crate jsonpath_rust

Json path

The library provides the basic functionality to find the slice of data according to the query. The idea comes from xpath for xml structures. The details can be found over there Therefore JSONPath is a query language for JSON, similar to XPath for XML. The jsonpath query is a set of assertions to specify the JSON fields that need to be verified.

Simple example

Let’s suppose we have a following json:

 {
  "shop": {
   "orders": [
      {"id": 1, "active": true},
      {"id": 2 },
      {"id": 3 },
      {"id": 4, "active": true}
    ]
  }
}

And we pursue to find all orders id having the field ‘active’ we can construct the jsonpath instance like that $.shop.orders[?(@.active)].id and get the result [1,4]

Another examples

{ "store": {
    "book": [
      { "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      { "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      { "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      { "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  }
}

and examples

• $.store.book[*].author : the authors of all books in the store
• $..book[?(@.isbn)] : filter all books with isbn number
• $..book[?(@.price<10)] : filter all books cheapier than 10
• $..* : all Elements in XML document. All members of JSON structure
• $..book[0,1] : The first two books
• $..book[:2] : The first two books

Operators

• $ : Pointer to the root of the json. It is gently advising to start every jsonpath from the root. Also, inside the filters to point out that the path is starting from the root.
• @Pointer to the current element inside the filter operations.It is used inside the filter operations to iterate the collection.
• * or [*]Wildcard. It brings to the list all objects and elements regardless their names.It is analogue a flatmap operation.
• <..>| Descent operation. It brings to the list all objects, children of that objects and etc It is analogue a flatmap operation.
• .<name> or .['<name>']the key pointing to the field of the objectIt is used to obtain the specific field.
• ['<name>' (, '<name>')]the list of keysthe same usage as for a single key but for list
• [<number>]the filter getting the element by its index.
• [<number> (, <number>)]the list if elements of array according to their indexes representing these numbers. |
• [<start>:<end>:<step>]slice operator to get a list of element operating with their indexes. By default step = 1, start = 0, end = array len. The elements can be omitted [:]
• [?(<expression>)]the logical expression to filter elements in the list.It is used with arrays preliminary.

Examples

 use serde_json::{json,Value};
 use jsonpath_rust::jp_v;
 use self::jsonpath_rust::JsonPathFinder;
 use self::jsonpath_rust::JsonPathValue;

 fn test(){
     let  finder = JsonPathFinder::from_str(r#"{"first":{"second":[{"active":1},{"passive":1}]}}"#, "$.first.second[?(@.active)]").unwrap();
     let slice_of_data:Vec<JsonPathValue<Value>> = finder.find_slice();
     let js = json!({"active":1});
     assert_eq!(slice_of_data, jp_v![&js;"$.first.second[0]",]);
 }

or even simpler:

 use serde_json::{json,Value};
 use self::jsonpath_rust::JsonPathFinder;
 use self::jsonpath_rust::JsonPathValue;
 fn test(json: &str, path: &str, expected: Vec<JsonPathValue<Value>>) {
    match JsonPathFinder::from_str(json, path) {
        Ok(finder) => assert_eq!(finder.find_slice(), expected),
        Err(e) => panic!("error while parsing json or jsonpath: {}", e)
    }


 }

Modules

• parser
  The parser for the jsonpath. The module grammar denotes the structure of the parsing grammar
• path

Macros

• chain
• filter
• function
• idx
• jp_v
  just to create a json path value of data Example:
• op
• path

Structs

• JsonPathFinder
  The base structure stitching the json instance and jsonpath instance
• JsonPathInst

Enums

• JsonPathValue
  A result of json path Can be either a slice of initial data or a new generated value(like length of array)
• JsonPtr
  Json paths may return either pointers to the original json or new data. This custom pointer type allows us to handle both cases. Unlike JsonPathValue, this type does not represent NoValue to allow the implementation of Deref.

Traits

• JsonPathQuery
  the trait allows to mix the method path to the value of Value and thus the using can be shortened to the following one: